package com.Lemon.Zhkuhealth.admin.controller;

import com.Lemon.Zhkuhealh.api.service.IReserveSettingService;
import com.Lemon.Zhkuhealth.common.constant.MessageConstant;
import com.Lemon.Zhkuhealth.common.pojo.entity.CheckGroup;
import com.Lemon.Zhkuhealth.common.pojo.entity.ReserveSetting;
import com.Lemon.Zhkuhealth.common.pojo.vo.CheckGroupVo;
import com.Lemon.Zhkuhealth.common.util.PageResult;
import com.Lemon.Zhkuhealth.common.util.QueryPageBean;
import com.Lemon.Zhkuhealth.common.util.R;
import com.Lemon.Zhkuhealh.api.service.ICheckGroupService;

import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;


@Slf4j
@RestController
@RequestMapping("/checkgroup")
public class CheckGroupController {
    /**
     * 通过Dubbo从注册中心获取服务接口
     */
    @DubboReference
    private ICheckGroupService checkGroupService;
    private IReserveSettingService reserveSettingService;

    /**
     * 查询所有，套餐功能使用
     *
     * @return
     */
    @GetMapping("/findAll")
    public R findAll() {
        List<CheckGroup> checkGroupList = checkGroupService.list();
        if (checkGroupList != null && !checkGroupList.isEmpty()) {
            return new R(true, MessageConstant.QUERY_CHECKGROUP_SUCCESS, checkGroupList);
        }
        return new R(false, MessageConstant.QUERY_CHECKGROUP_FAIL);
    }

    /**
     * 新增检查组
     * @param checkGroupVo
     * @return
     */
    @PostMapping("/add")
    public R add(@RequestBody CheckGroupVo checkGroupVo) {
        CheckGroup checkGroup = checkGroupVo.getCheckGroup();
        List<Long> checkItemIds = checkGroupVo.getCheckitemIds();
        try {
            checkGroupService.save(checkGroup, checkItemIds);
        } catch (Exception e) {
            log.error("添加检查组失败, {}", e.getMessage());
            return new R(false, MessageConstant.ADD_CHECKGROUP_FAIL);
        }
        return new R(true, MessageConstant.ADD_CHECKGROUP_SUCCESS);
    }

    /**
     * 根据条件参数查询检查组列表数据
     *
     * @param queryPageBean
     * @return
     */
    @PostMapping("/findPage")
    public PageResult<CheckGroup> findPage(@RequestBody QueryPageBean queryPageBean) {
        PageResult<CheckGroup> pageResult =
                checkGroupService.page(
                        queryPageBean.getCurrentPage(),
                        queryPageBean.getPageSize(),
                        queryPageBean.getQueryString());
        return pageResult;
    }

    /**
     * 根据检查组ID查找关联的所有检查项ID，回显到编辑页面
     * @param id
     * @return
     */
    @GetMapping("/findCheckItemIdsByCheckGroupId")
    public R findCheckItemIdsByCheckGroupId(Long id) {
        List<Long> checkItemIds = checkGroupService.listCheckItemIdsByCheckGroupId(id);
        if (!ObjectUtils.isEmpty(checkItemIds)) {
            return new R(true, "查询关联的检查项成功", checkItemIds);
        }
        return new R(false, "查询关联的检查项失败");
    }

    /**
     * 根据ID查询检查组信息，回显到编辑页面
     * @param id
     * @return
     */
    @GetMapping("/findById")
    public R findById(Long id) {
        CheckGroup checkGroup = null;
        try {
            checkGroup = checkGroupService.getById(id);
        } catch (Exception e) {
            log.error("查询检查组失败, {}", e.getMessage());
            return new R(false, MessageConstant.QUERY_CHECKGROUP_FAIL);
        }

        if(checkGroup == null) {
            // 当查询不到结果时，也需要返回一个相应的消息
            return new R(false, "检查组未找到");
        }

        return new R(true, MessageConstant.QUERY_CHECKGROUP_SUCCESS, checkGroup);
    }

    /**
     * 更新检查组
     *
     * @param checkGroup
     * @param checkItemIds
     * @return
     */
    @PostMapping("/edit")
    public R edit(@RequestBody CheckGroupVo checkGroupVo) {
        CheckGroup checkGroup = checkGroupVo.getCheckGroup();
        List<Long> checkItemIds = checkGroupVo.getCheckitemIds();
        try {
            checkGroupService.update(checkGroup, checkItemIds);
        } catch (Exception e) {
            new R(false, MessageConstant.EDIT_CHECKGROUP_FAIL);
        }
        return new R(true, MessageConstant.EDIT_CHECKGROUP_SUCCESS);
    }
    /**
     * 删除检查组
     * @param id 检查组ID
     * @return 统一结果封装R
     */
    @DeleteMapping("/delete") // 前端通过查询参数传递ID，所以这里不需要路径变量
    public R delete(@RequestParam("id") Long id) { // 使用 @RequestParam("id") 来接收名为 "id" 的查询参数
        try {
            checkGroupService.deleteById(id); // 调用服务层的删除方法
        } catch (Exception e) {
            log.error("删除检查组失败, id: {}, 错误信息: {}", id, e.getMessage());
            // 通常，如果删除失败，可能是存在其他关联数据（例如，如果检查组被套餐引用，但没有配置级联删除或逻辑删除）
            // 此时可以返回更具体的错误信息，比如“该检查组已被使用，无法删除”
            return new R(false, MessageConstant.DELETE_CHECKGROUP_FAIL + ": " + e.getMessage());
        }
        return new R(true, MessageConstant.DELETE_CHECKGROUP_SUCCESS);
    }
    /**
     * 批量编辑/保存预约设置
     *
     * @param reserveSettings 预约设置列表
     * @return 统一响应结果
     */
    @RequestMapping("/editReservations") // 通常对于更新会用 @PostMapping
    public R editReservations(@RequestBody List<ReserveSetting> reserveSettings) {
        try {
            // 调用服务层进行批量更新或保存操作
            // 这里的 reserveSettingService.editReservations 是一个假设的服务方法，
            // 您需要在 IReserveSettingService 接口和其实现中添加相应的方法。
            // 该方法应处理以下逻辑：
            // 1. 遍历 reserveSettings 列表
            // 2. 对于每个 ReserveSetting 对象，根据 orderDate 判断是更新现有记录还是插入新记录
            //    - 可以先根据 orderDate 查询是否存在记录
            //    - 如果存在，则更新可预约人数
            //    - 如果不存在，则插入新记录
            reserveSettingService.editReservations(reserveSettings);
            return new R(true, MessageConstant.EDIT_ORDERSETTING_SUCCESS);
        } catch (Exception e) {
            log.error("保存预约设置失败: {}", e.getMessage(), e); // 使用 slf4j 记录错误
            return new R(false, MessageConstant.EDIT_ORDERSETTING_FAIL);
        }
    }

    @RequestMapping("/getOrderSettingByMonth")
    public R getOrderSettingByMonth(String date) {
        try {
            List<ReserveSetting> orderSettings = reserveSettingService.listReserveSettingByMonth(date);
            return new R(true, MessageConstant.GET_ORDERSETTING_SUCCESS, orderSettings);
        } catch (Exception e) {
            log.error("获取月度预约设置失败: {}", e.getMessage(), e); // 使用 slf4j 记录错误
            return new R(false, MessageConstant.GET_ORDERSETTING_FAIL);
        }
    }
}
